/*******************************************************************
 *
 *  freetype.h
 *
 *    High-level interface specification.
 *
 *  Copyright 1996-1999 by
 *  David Turner, Robert Wilhelm, and Werner Lemberg.
 *
 *  This file is part of the FreeType project and may only be used,
 *  modified, and distributed under the terms of the FreeType project
 *  license, LICENSE.TXT.  By continuing to use, modify, or distribute
 *  this file you indicate that you have read the license and
 *  understand and accept it fully.
 *
 *  Note:
 *
 *    This is the only file that should be included by client
 *    application sources.  All other types and functions defined
 *    in the `tt*.h' files are library internals and should not be
 *    included.
 *
 ******************************************************************/

#ifndef FREETYPE_H
#define FREETYPE_H

#define TT_FREETYPE_MAJOR  1
#define TT_FREETYPE_MINOR  3

#include "fterrid.h"
#include "ftnameid.h"

/* To make freetype.h independent from configuration files we check */
/* whether EXPORT_DEF has been defined already.                     */

#ifndef EXPORT_DEF
#define EXPORT_DEF  extern
#endif

/* The same for TT_Text.  If you define the HAVE_TT_TEXT macro, you */
/* have to provide a typedef declaration for TT_Text before         */
/* including this file.                                             */

#ifndef HAVE_TT_TEXT
#define HAVE_TT_TEXT
typedef char TT_Text;			/* The data type to represent */

					  /* file name string elements. */
#endif

#ifdef __cplusplus
extern "C" {
#endif

  /*******************************************************************/
	/*                                                                 */
	/*  FreeType types definitions.                                    */
	/*                                                                 */
	/*  All these begin with a 'TT_' prefix.                           */
	/*                                                                 */
  /*******************************************************************/

	typedef int TT_Bool;

	typedef signed long TT_Fixed;	/* signed fixed 16.16 float */

	typedef signed short TT_FWord;	/* distance in FUnits */
	typedef unsigned short TT_UFWord;	/* unsigned distance  */

	typedef char TT_String;
	typedef signed char TT_Char;
	typedef unsigned char TT_Byte;
	typedef signed short TT_Short;
	typedef unsigned short TT_UShort;
	typedef int TT_Int;
	typedef unsigned int TT_UInt;
	typedef signed long TT_Long;
	typedef unsigned long TT_ULong;

	typedef signed short TT_F2Dot14;	/* Signed fixed float 2.14 used for */
	/* unit vectors, with layout        */
	/*                                  */
	/*   s : 1  -- sign bit             */
	/*   m : 1  -- integer bit          */
	/*   f : 14 -- unsigned fractional  */
	/*                                  */
	/* `s:m' is the 2-bit signed int    */
	/* value to which the positive      */
	/* fractional part should be added. */

	typedef signed long TT_F26Dot6;	/* 26.6 fixed float, used for       */
	/* glyph points pixel coordinates.  */

	typedef signed long TT_Pos;	/* Point position, expressed either */
	/* in fractional pixels or notional */
	/* units, depending on context.     */
	/* For example, glyph coordinates   */
	/* returned by TT_Load_Glyph() are  */
	/* expressed in font units if       */
	/* scaling wasn't requested, and    */
	/* in 26.6 fractional pixels if it  */
	/* was.                             */

	struct TT_UnitVector_ {		/* guess what...  */
		TT_F2Dot14 x;
		TT_F2Dot14 y;
	};

	typedef struct TT_UnitVector_ TT_UnitVector;

	struct TT_Vector_ {			/* simple vector type */
		TT_F26Dot6 x;
		TT_F26Dot6 y;
	};

	typedef struct TT_Vector_ TT_Vector;

	/* A simple 2x2 matrix used for transformations. */
	/* You should use 16.16 fixed floats.            */
	/*                                               */
	/*   x' = xx*x + xy*y                            */
	/*   y' = yx*x + yy*y                            */
	/*                                               */

	struct TT_Matrix_ {
		TT_Fixed xx, xy;
		TT_Fixed yx, yy;
	};

	typedef struct TT_Matrix_ TT_Matrix;

	/* A structure used to describe the source glyph to the renderer. */

	struct TT_Outline_ {
		TT_Short n_contours;	/* number of contours in glyph   */
		TT_UShort n_points;		/* number of points in the glyph */

		TT_Vector *points;		/* the outline's points   */
		TT_Byte *flags;			/* the points flags       */
		TT_UShort *contours;	/* the contour end points */

		/* The following flag indicates that the outline owns the arrays it  */
		/* refers to.  Typically, this is true of outlines created from the  */
		/* TT_New_Outline() API, while it isn't for those returned by        */
		/* TT_Get_Glyph_Outline().                                           */

		TT_Bool owner;			/* The outline owns the coordinates, */
		/* flags and contours array it uses. */

		/* The following flags are set automatically by                      */
		/* TT_Get_Glyph_Outline().  Their meaning is the following:          */
		/*                                                                   */
		/*  high_precision   If true, the scan-line converter will use a     */
		/*                   higher precision to render bitmaps (i.e., a     */
		/*                   1/1024 pixel precision).  This is important for */
		/*                   small ppem sizes.                               */
		/*                                                                   */
		/*  second_pass      If true, the scan-line converter performs a     */
		/*                   second sweep phase dedicated to find vertical   */
		/*                   drop-outs.  If false, only horizontal drop-outs */
		/*                   will be checked during the first vertical       */
		/*                   sweep (yes, this is a bit confusing but it is   */
		/*                   really the way it should work).  This is        */
		/*                   important for small ppems too.                  */
		/*                                                                   */
		/*  dropout_mode     Specifies the TrueType drop-out mode to use for */
		/*                   continuity checking.  Valid values are 0 (no    */
		/*                   check), 1, 2, 4, and 5.                         */
		/*                                                                   */
		/*  Most of the engine's users will safely ignore these fields...    */

		TT_Bool high_precision;	/* high precision rendering */
		TT_Bool second_pass;	/* two sweeps rendering     */
		TT_Char dropout_mode;	/* dropout mode             */
	};

	typedef struct TT_Outline_ TT_Outline;

	/* A structure used to describe a simple bounding box. */

	struct TT_BBox_ {
		TT_Pos xMin;
		TT_Pos yMin;
		TT_Pos xMax;
		TT_Pos yMax;
	};

	typedef struct TT_BBox_ TT_BBox;

	/* A structure used to return glyph metrics.                          */
	/*                                                                    */
	/* The `bearingX' isn't called `left-side bearing' anymore because    */
	/* it has different meanings depending on the glyph's orientation.    */
	/*                                                                    */
	/* The same is true for `bearingY', which is the top-side bearing     */
	/* defined by the TT_Spec, i.e., the distance from the baseline to    */
	/* the top of the glyph's bbox.  According to our current convention, */
	/* this is always the same as `bbox.yMax' but we make it appear for   */
	/* consistency in its proper field.                                   */
	/*                                                                    */
	/* The `advance' field is the advance width for horizontal layout,    */
	/* and advance height for vertical layouts.                           */

	struct TT_Glyph_Metrics_ {
		TT_BBox bbox;			/* glyph bounding box */

		TT_Pos bearingX;		/* left-side bearing                    */
		TT_Pos bearingY;		/* top-side bearing, per se the TT spec */

		TT_Pos advance;			/* advance width (or height) */
	};

	typedef struct TT_Glyph_Metrics_ TT_Glyph_Metrics;

	/* A structure used to return horizontal _and_ vertical glyph         */
	/* metrics.                                                           */
	/*                                                                    */
	/* A glyph can be used either in a horizontal or vertical layout.     */
	/* Its glyph metrics vary with orientation.  The TT_Big_Glyph_Metrics */
	/* structure is used to return _all_ metrics in one call.             */

	struct TT_Big_Glyph_Metrics_ {
		TT_BBox bbox;			/* glyph bounding box */

		TT_Pos horiBearingX;	/* left side bearing in horizontal layouts */
		TT_Pos horiBearingY;	/* top side bearing in horizontal layouts  */

		TT_Pos vertBearingX;	/* left side bearing in vertical layouts */
		TT_Pos vertBearingY;	/* top side bearing in vertical layouts  */

		TT_Pos horiAdvance;		/* advance width for horizontal layout */
		TT_Pos vertAdvance;		/* advance height for vertical layout  */

		/* The following fields represent unhinted scaled metrics values. */
		/* They can be useful for applications needing to do some device  */
		/* independent placement of glyphs.                               */
		/*                                                                */
		/* Applying these metrics to hinted glyphs will most surely ruin  */
		/* the grid fitting performed by the bytecode interpreter.  These */
		/* values are better used to compute accumulated positioning      */
		/* distances.                                                     */

		TT_Pos linearHoriBearingX;	/* linearly scaled horizontal lsb     */
		TT_Pos linearHoriAdvance;	/* linearly scaled horizontal advance */

		TT_Pos linearVertBearingY;	/* linearly scaled vertical tsb     */
		TT_Pos linearVertAdvance;	/* linearly scaled vertical advance */
	};

	typedef struct TT_Big_Glyph_Metrics_ TT_Big_Glyph_Metrics;

	/* A structure used to return instance metrics. */

	struct TT_Instance_Metrics_ {
		TT_F26Dot6 pointSize;	/* char. size in points (1pt = 1/72 inch) */

		TT_UShort x_ppem;		/* horizontal pixels per EM square */
		TT_UShort y_ppem;		/* vertical pixels per EM square   */

		TT_Fixed x_scale;		/* 16.16 to convert from EM units to 26.6 pix */
		TT_Fixed y_scale;		/* 16.16 to convert from EM units to 26.6 pix */

		TT_UShort x_resolution;	/* device horizontal resolution in dpi */
		TT_UShort y_resolution;	/* device vertical resolution in dpi   */
	};

	typedef struct TT_Instance_Metrics_ TT_Instance_Metrics;

	/* Flow constants:                                             */
	/*                                                             */
	/* The flow of a bitmap refers to the way lines are oriented   */
	/* within the bitmap data, i.e., the orientation of the Y      */
	/* coordinate axis.                                            */
	/*                                                             */
	/* For example, if the first bytes of the bitmap pertain to    */
	/* its top-most line, then the flow is `down'.  If these bytes */
	/* pertain to its lowest line, the the flow is `up'.           */

#define TT_Flow_Down  -1		/* bitmap is oriented from top to bottom */
#define TT_Flow_Up     1		/* bitmap is oriented from bottom to top */
#define TT_Flow_Error  0		/* an error occurred during rendering    */

	/* A structure used to describe the target bitmap or pixmap to the   */
	/* renderer.  Note that there is nothing in this structure that      */
	/* gives the nature of the buffer.                                   */
	/*                                                                   */
	/* IMPORTANT NOTE:                                                   */
	/*                                                                   */
	/*   In the case of a pixmap, the `width' and `cols' fields must     */
	/*   have the _same_ values, and _must_ be padded to 32-bits, i.e.,  */
	/*   be a multiple of 4.  Clipping problems will arise otherwise,    */
	/*   if not even page faults!                                        */
	/*                                                                   */
	/*   The typical settings are:                                       */
	/*                                                                   */
	/*   - for a WxH bitmap:                                             */
	/*                                                                   */
	/*       rows  = H                                                   */
	/*       cols  = (W+7) / 8                                           */
	/*       width = W                                                   */
	/*       flow  = your_choice                                         */
	/*                                                                   */
	/*   - for a WxH pixmap:                                             */
	/*                                                                   */
	/*       rows  = H                                                   */
	/*       cols  = (W+3) & ~3                                          */
	/*       width = cols                                                */
	/*       flow  = your_choice                                         */

	struct TT_Raster_Map_ {
		int rows;				/* number of rows                    */
		int cols;				/* number of columns (bytes) per row */
		int width;				/* number of pixels per line         */
		int flow;				/* bitmap orientation                */

		void *bitmap;			/* bit/pixmap buffer                 */
		long size;				/* bit/pixmap size in bytes          */
	};

	typedef struct TT_Raster_Map_ TT_Raster_Map;

	/* ------ The font header TrueType table structure ------ */

	struct TT_Header_ {
		TT_Fixed Table_Version;
		TT_Fixed Font_Revision;

		TT_Long CheckSum_Adjust;
		TT_Long Magic_Number;

		TT_UShort Flags;
		TT_UShort Units_Per_EM;

		TT_Long Created[2];
		TT_Long Modified[2];

		TT_FWord xMin;
		TT_FWord yMin;
		TT_FWord xMax;
		TT_FWord yMax;

		TT_UShort Mac_Style;
		TT_UShort Lowest_Rec_PPEM;

		TT_Short Font_Direction;
		TT_Short Index_To_Loc_Format;
		TT_Short Glyph_Data_Format;
	};

	typedef struct TT_Header_ TT_Header;

	/* ------ The horizontal header TrueType table structure ------ */

  /*******************************************************/
	/*  This structure is the one defined by the TrueType  */
	/*  specification, plus two fields used to link the    */
	/*  font-units metrics to the header.                  */

	struct TT_Horizontal_Header_ {
		TT_Fixed Version;
		TT_FWord Ascender;
		TT_FWord Descender;
		TT_FWord Line_Gap;

		TT_UFWord advance_Width_Max;	/* advance width maximum */

		TT_FWord min_Left_Side_Bearing;	/* minimum left-sb       */
		TT_FWord min_Right_Side_Bearing;	/* minimum right-sb      */
		TT_FWord xMax_Extent;	/* xmax extents          */
		TT_FWord caret_Slope_Rise;
		TT_FWord caret_Slope_Run;

		TT_Short Reserved0, Reserved1, Reserved2, Reserved3, Reserved4;

		TT_Short metric_Data_Format;
		TT_UShort number_Of_HMetrics;

		/* The following fields are not defined by the TrueType specification */
		/* but they're used to connect the metrics header to the relevant     */
		/* `HMTX' or `VMTX' table.                                            */

		void *long_metrics;
		void *short_metrics;
	};

	typedef struct TT_Horizontal_Header_ TT_Horizontal_Header;

  /*******************************************************/
	/*  This structure is the one defined by the TrueType  */
	/*  specification.  Note that it has exactly the same  */
	/*  layout as the horizontal header (both are loaded   */
	/*  by the same function).                             */

	struct TT_Vertical_Header_ {
		TT_Fixed Version;
		TT_FWord Ascender;
		TT_FWord Descender;
		TT_FWord Line_Gap;

		TT_UFWord advance_Height_Max;	/* advance height maximum */

		TT_FWord min_Top_Side_Bearing;	/* minimum left-sb or top-sb       */
		TT_FWord min_Bottom_Side_Bearing;	/* minimum right-sb or bottom-sb   */
		TT_FWord yMax_Extent;	/* xmax or ymax extents            */
		TT_FWord caret_Slope_Rise;
		TT_FWord caret_Slope_Run;
		TT_FWord caret_Offset;

		TT_Short Reserved1, Reserved2, Reserved3, Reserved4;

		TT_Short metric_Data_Format;
		TT_UShort number_Of_VMetrics;

		/* The following fields are not defined by the TrueType specification */
		/* but they're used to connect the metrics header to the relevant     */
		/* `HMTX' or `VMTX' table.                                            */

		void *long_metrics;
		void *short_metrics;
	};

	typedef struct TT_Vertical_Header_ TT_Vertical_Header;

	/* ------ The OS/2 table ------ */

  /************************************************************************/
	/* Note that since FreeType 1.3, we support Mac fonts which do not have */
	/* an OS/2 table.  In this case the `version' field will be set to      */
	/* 0xFFFF by the table loader; all other fields should be 0.            */

	struct TT_OS2_ {
		TT_UShort version;		/* 0x0001 */
		TT_FWord xAvgCharWidth;
		TT_UShort usWeightClass;
		TT_UShort usWidthClass;
		TT_Short fsType;
		TT_FWord ySubscriptXSize;
		TT_FWord ySubscriptYSize;
		TT_FWord ySubscriptXOffset;
		TT_FWord ySubscriptYOffset;
		TT_FWord ySuperscriptXSize;
		TT_FWord ySuperscriptYSize;
		TT_FWord ySuperscriptXOffset;
		TT_FWord ySuperscriptYOffset;
		TT_FWord yStrikeoutSize;
		TT_FWord yStrikeoutPosition;
		TT_Short sFamilyClass;

		TT_Byte panose[10];

		TT_ULong ulUnicodeRange1;	/* Bits 0-31   */
		TT_ULong ulUnicodeRange2;	/* Bits 32-63  */
		TT_ULong ulUnicodeRange3;	/* Bits 64-95  */
		TT_ULong ulUnicodeRange4;	/* Bits 96-127 */

		TT_Char achVendID[4];

		TT_UShort fsSelection;
		TT_UShort usFirstCharIndex;
		TT_UShort usLastCharIndex;
		TT_Short sTypoAscender;
		TT_Short sTypoDescender;
		TT_Short sTypoLineGap;
		TT_UShort usWinAscent;
		TT_UShort usWinDescent;

		/* only version 1 tables: */

		TT_ULong ulCodePageRange1;	/* Bits 0-31   */
		TT_ULong ulCodePageRange2;	/* Bits 32-63  */
	};

	typedef struct TT_OS2_ TT_OS2;

	/* ------ The PostScript table ------ */

	struct TT_Postscript_ {
		TT_Fixed FormatType;
		TT_Fixed italicAngle;
		TT_FWord underlinePosition;
		TT_FWord underlineThickness;
		TT_ULong isFixedPitch;
		TT_ULong minMemType42;
		TT_ULong maxMemType42;
		TT_ULong minMemType1;
		TT_ULong maxMemType1;

		/* Glyph names follow in the file, but we don't         */
		/* load them by default.  See the ftxpost.c extension.  */
	};

	typedef struct TT_Postscript_ TT_Postscript;

	/* ------ The horizontal device metrics table (`hdmx') ------ */

	struct TT_Hdmx_Record_ {
		TT_Byte ppem;
		TT_Byte max_width;
		TT_Byte *widths;
	};

	typedef struct TT_Hdmx_Record_ TT_Hdmx_Record;

	struct TT_Hdmx_ {
		TT_UShort version;
		TT_Short num_records;
		TT_Hdmx_Record *records;
	};

	typedef struct TT_Hdmx_ TT_Hdmx;

	/* A structure used to describe face properties. */

	struct TT_Face_Properties_ {
		TT_UShort num_Glyphs;	/* number of glyphs in face              */
		TT_UShort max_Points;	/* maximum number of points in a glyph   */
		TT_UShort max_Contours;	/* maximum number of contours in a glyph */

		TT_UShort num_CharMaps;	/* number of charmaps in the face     */
		TT_UShort num_Names;	/* number of name records in the face */

		TT_ULong num_Faces;		/* 1 for normal TrueType files, and the  */
		/* number of embedded faces for TrueType */
		/* collections                           */

		TT_Header *header;		/* TrueType header table          */
		TT_Horizontal_Header *horizontal;	/* TrueType horizontal header     */
		TT_OS2 *os2;			/* TrueType OS/2 table            */
		TT_Postscript *postscript;	/* TrueType Postscript table      */
		TT_Hdmx *hdmx;			/* TrueType hor. dev. metr. table */
		TT_Vertical_Header *vertical;	/* TT Vertical header, if present */
	};

	typedef struct TT_Face_Properties_ TT_Face_Properties;

	/* Here are the definitions of the handle types used for FreeType's */
	/* most common objects accessed by the client application.  We use  */
	/* a simple trick:                                                  */
	/*                                                                  */
	/*   Each handle type is a structure that only contains one         */
	/*   pointer.  The advantage of structures is that they are         */
	/*   mutually exclusive types.  We could have defined the           */
	/*   following types:                                               */
	/*                                                                  */
	/*     typedef void*  TT_Stream;                                    */
	/*     typedef void*  TT_Face;                                      */
	/*     typedef void*  TT_Instance;                                  */
	/*     typedef void*  TT_Glyph;                                     */
	/*     typedef void*  TT_CharMap;                                   */
	/*                                                                  */
	/*   but these would have allowed lines like:                       */
	/*                                                                  */
	/*      stream = instance;                                          */
	/*                                                                  */
	/*   in the client code this would be a severe bug, unnoticed       */
	/*   by the compiler!                                               */
	/*                                                                  */
	/*   Thus, we enforce type checking with a simple language          */
	/*   trick...                                                       */
	/*                                                                  */
	/*   NOTE:  Some macros are defined in tttypes.h to perform         */
	/*          automatic type conversions for library hackers...       */

	struct TT_Engine_ {
		void *z;
	};
	struct TT_Stream_ {
		void *z;
	};
	struct TT_Face_ {
		void *z;
	};
	struct TT_Instance_ {
		void *z;
	};
	struct TT_Glyph_ {
		void *z;
	};
	struct TT_CharMap_ {
		void *z;
	};

	typedef struct TT_Engine_ TT_Engine;	/* engine instance           */
	typedef struct TT_Stream_ TT_Stream;	/* stream handle type        */
	typedef struct TT_Face_ TT_Face;	/* face handle type          */
	typedef struct TT_Instance_ TT_Instance;	/* instance handle type      */
	typedef struct TT_Glyph_ TT_Glyph;	/* glyph handle type         */
	typedef struct TT_CharMap_ TT_CharMap;	/* character map handle type */

	/* Almost all functions return an error code of this type. */

	typedef long TT_Error;

  /*******************************************************************/
	/*                                                                 */
	/*  FreeType API                                                   */
	/*                                                                 */
	/*  All these begin with a `TT_' prefix.                           */
	/*                                                                 */
	/*  Most of them are implemented in the `ttapi.c' source file.     */
	/*                                                                 */
  /*******************************************************************/

	/* Get version information. */

	EXPORT_DEF TT_Error TT_FreeType_Version(int *major, int *minor);

	/* Initialize the engine. */

	EXPORT_DEF TT_Error TT_Init_FreeType(TT_Engine * engine);

	/* Finalize the engine, and release all allocated objects. */

	EXPORT_DEF TT_Error TT_Done_FreeType(TT_Engine engine);

	/* Set the gray level palette.  This is an array of 5 bytes used */
	/* to produce the font smoothed pixmaps.  By convention:         */
	/*                                                               */
	/*  palette[0] = background (white)                              */
	/*  palette[1] = light                                           */
	/*  palette[2] = medium                                          */
	/*  palette[3] = dark                                            */
	/*  palette[4] = foreground (black)                              */
	/*                                                               */

	EXPORT_DEF TT_Error TT_Set_Raster_Gray_Palette(TT_Engine engine, TT_Byte * palette);

	/* ----------------------- face management ----------------------- */

	/* Open a new TrueType font file, and returns a handle for  */
	/* it in variable '*face'.                                  */
	/*                                                          */
	/* Note: The file can be either a TrueType file (*.ttf) or  */
	/*       a TrueType collection (*.ttc, in this case, only   */
	/*       the first face is opened).  The number of faces in */
	/*       the same collection can be obtained in the face's  */
	/*       properties, using TT_Get_Face_Properties() and the */
	/*       `max_Faces' field.                                 */

	EXPORT_DEF TT_Error TT_Open_Face(TT_Engine engine, const TT_Text * fontPathName, TT_Face * face);

	/* Open a TrueType font file located inside a collection. */
	/* The font is assigned by its index in `fontIndex'.      */

	EXPORT_DEF TT_Error TT_Open_Collection(TT_Engine engine, const TT_Text * collectionPathName, TT_ULong fontIndex,
										   TT_Face * face);

	/* Return face properties in the `properties' structure.          */
	/*                                                                */
	/* Note that since version 1.3, we support font files with no     */
	/* OS/2 table (mainly old Mac fonts).  In this case, the OS/2     */
	/* `version' field will be set to 0xFFFF, and all other fields    */
	/* will be zeroed.                                                */

	EXPORT_DEF TT_Error TT_Get_Face_Properties(TT_Face face, TT_Face_Properties * properties);

	/* Set a face object's generic pointer */

	EXPORT_DEF TT_Error TT_Set_Face_Pointer(TT_Face face, void *data);

	/* Get a face object's generic pointer */

	EXPORT_DEF void *TT_Get_Face_Pointer(TT_Face face);

	/* Close a face's file handle to save system resources.  The file */
	/* will be re-opened automatically on the next disk access.       */

	EXPORT_DEF TT_Error TT_Flush_Face(TT_Face face);

	/* Get a face's glyph metrics expressed in font units.  Returns any    */
	/* number of arrays.  Set the fields to NULL if you are not interested */
	/* by a given array.                                                   */

	EXPORT_DEF TT_Error TT_Get_Face_Metrics(TT_Face face, TT_UShort firstGlyph, TT_UShort lastGlyph,
											TT_Short * leftBearings, TT_UShort * widths, TT_Short * topBearings,
											TT_UShort * heights);

	/* Close a given font object, destroying all associated */
	/* instances.                                           */

	EXPORT_DEF TT_Error TT_Close_Face(TT_Face face);

	/* Get font or table data. */

	EXPORT_DEF TT_Error TT_Get_Font_Data(TT_Face face, TT_ULong tag, TT_Long offset, void *buffer, TT_Long * length);

	/* A simple macro to build table tags from ASCII chars */

#define MAKE_TT_TAG( _x1, _x2, _x3, _x4 ) \
          (((TT_ULong)_x1 << 24) |        \
           ((TT_ULong)_x2 << 16) |        \
           ((TT_ULong)_x3 << 8)  |        \
            (TT_ULong)_x4)

	/* ----------------------- instance management -------------------- */

	/* Open a new font instance and returns an instance handle */
	/* for it in `*instance'.                                  */

	EXPORT_DEF TT_Error TT_New_Instance(TT_Face face, TT_Instance * instance);

	/* Set device resolution for a given instance.  The values are      */
	/* given in dpi (Dots Per Inch).  Default is 96 in both directions. */

	EXPORT_DEF TT_Error TT_Set_Instance_Resolutions(TT_Instance instance, TT_UShort xResolution, TT_UShort yResolution);

	/* Set the pointsize for a given instance.  Default is 10pt. */

	EXPORT_DEF TT_Error TT_Set_Instance_CharSize(TT_Instance instance, TT_F26Dot6 charSize);

	EXPORT_DEF TT_Error TT_Set_Instance_CharSizes(TT_Instance instance, TT_F26Dot6 charWidth, TT_F26Dot6 charHeight);

#define TT_Set_Instance_PointSize( ins, ptsize )   \
            TT_Set_Instance_CharSize( ins, ptsize*64L )

	EXPORT_DEF TT_Error TT_Set_Instance_PixelSizes(TT_Instance instance, TT_UShort pixelWidth, TT_UShort pixelHeight,
												   TT_F26Dot6 pointSize);

	/* This function has been deprecated!  Do not use it, as it      */
	/* doesn't work reliably.  You can perfectly control hinting     */
	/* yourself when loading glyphs, then apply transforms as usual. */

	EXPORT_DEF TT_Error TT_Set_Instance_Transform_Flags(TT_Instance instance, TT_Bool rotated, TT_Bool stretched);

	/* Return instance metrics in `metrics'. */

	EXPORT_DEF TT_Error TT_Get_Instance_Metrics(TT_Instance instance, TT_Instance_Metrics * metrics);

	/* Set an instance's generic pointer. */

	EXPORT_DEF TT_Error TT_Set_Instance_Pointer(TT_Instance instance, void *data);

	/* Get an instance's generic pointer. */

	EXPORT_DEF void *TT_Get_Instance_Pointer(TT_Instance instance);

	/* Close a given instance object, destroying all associated data. */

	EXPORT_DEF TT_Error TT_Done_Instance(TT_Instance instance);

	/* ----------------------- glyph management ----------------------- */

	/* Create a new glyph object related to the given `face'. */

	EXPORT_DEF TT_Error TT_New_Glyph(TT_Face face, TT_Glyph * glyph);

	/* Discard (and destroy) a given glyph object. */

	EXPORT_DEF TT_Error TT_Done_Glyph(TT_Glyph glyph);

#define TTLOAD_SCALE_GLYPH                    1
#define TTLOAD_HINT_GLYPH                     2
#define TTLOAD_PEDANTIC                     128
#define TTLOAD_IGNORE_GLOBAL_ADVANCE_WIDTH  256

#define TTLOAD_DEFAULT  (TTLOAD_SCALE_GLYPH | TTLOAD_HINT_GLYPH)

	/* Load and process (scale/transform and hint) a glyph from the */
	/* given `instance'.  The glyph and instance handles must be    */
	/* related to the same face object.  The glyph index can be     */
	/* computed with a call to TT_Char_Index().                     */
	/*                                                              */
	/* The 'load_flags' argument is a combination of the macros     */
	/* TTLOAD_SCALE_GLYPH and TTLOAD_HINT_GLYPH.  Hinting will be   */
	/* applied only if the scaling is selected.                     */
	/*                                                              */
	/* If scaling is off (i.e., load_flags = 0), the returned       */
	/* outlines are in EM square coordinates (also called FUnits),  */
	/* extracted directly from the font with no hinting.  Other     */
	/* glyph metrics are also in FUnits.                            */
	/*                                                              */
	/* If scaling is on, the returned outlines are in fractional    */
	/* pixel units (i.e. TT_F26Dot6 = 26.6 fixed floats).           */
	/*                                                              */
	/* NOTE: The glyph index must be in the range 0..num_glyphs-1,  */
	/*       where `num_glyphs' is the total number of glyphs in    */
	/*       the font file (given in the face properties).          */

	EXPORT_DEF TT_Error TT_Load_Glyph(TT_Instance instance, TT_Glyph glyph, TT_UShort glyphIndex, TT_UShort loadFlags);

	/* Return glyph outline pointers in `outline'.  Note that the returned */
	/* pointers are owned by the glyph object, and will be destroyed with  */
	/* it.  The client application should _not_ change the pointers.       */

	EXPORT_DEF TT_Error TT_Get_Glyph_Outline(TT_Glyph glyph, TT_Outline * outline);

	/* Copy the glyph metrics into `metrics'. */

	EXPORT_DEF TT_Error TT_Get_Glyph_Metrics(TT_Glyph glyph, TT_Glyph_Metrics * metrics);

	/* Copy the glyph's big metrics into `metrics'. */
	/* Necessary to obtain vertical metrics.        */

	EXPORT_DEF TT_Error TT_Get_Glyph_Big_Metrics(TT_Glyph glyph, TT_Big_Glyph_Metrics * metrics);

	/* Render the glyph into a bitmap, with given position offsets.     */
	/*                                                                  */
	/* Note: Only use integer pixel offsets to preserve the fine        */
	/*       hinting of the glyph and the `correct' anti-aliasing       */
	/*       (where vertical and horizontal stems aren't grayed).  This */
	/*       means that `xOffset' and `yOffset' must be multiples       */
	/*       of 64!                                                     */

	EXPORT_DEF TT_Error TT_Get_Glyph_Bitmap(TT_Glyph glyph, TT_Raster_Map * map, TT_F26Dot6 xOffset,
											TT_F26Dot6 yOffset);

	/* Render the glyph into a pixmap, with given position offsets.     */
	/*                                                                  */
	/* Note: Only use integer pixel offsets to preserve the fine        */
	/*       hinting of the glyph and the `correct' anti-aliasing       */
	/*       (where vertical and horizontal stems aren't grayed).  This */
	/*       means that `xOffset' and `yOffset' must be multiples       */
	/*       of 64!                                                     */

	EXPORT_DEF TT_Error TT_Get_Glyph_Pixmap(TT_Glyph glyph, TT_Raster_Map * map, TT_F26Dot6 xOffset,
											TT_F26Dot6 yOffset);

	/* ----------------------- outline support ------------------------ */

	/* Allocate a new outline.  Reserve space for `numPoints' and */
	/* `numContours'.                                             */

	EXPORT_DEF TT_Error TT_New_Outline(TT_UShort numPoints, TT_Short numContours, TT_Outline * outline);

	/* Release an outline. */

	EXPORT_DEF TT_Error TT_Done_Outline(TT_Outline * outline);

	/* Copy an outline into another one. */

	EXPORT_DEF TT_Error TT_Copy_Outline(TT_Outline * source, TT_Outline * target);

	/* Render an outline into a bitmap. */

	EXPORT_DEF TT_Error TT_Get_Outline_Bitmap(TT_Engine engine, TT_Outline * outline, TT_Raster_Map * map);

	/* Render an outline into a pixmap. */

	EXPORT_DEF TT_Error TT_Get_Outline_Pixmap(TT_Engine engine, TT_Outline * outline, TT_Raster_Map * map);

	/* Return an outline's bounding box -- this function is slow as it */
	/* performs a complete scan-line process, without drawing, to get  */
	/* the most accurate values.                                       */

	EXPORT_DEF TT_Error TT_Get_Outline_BBox(TT_Outline * outline, TT_BBox * bbox);

	/* Apply a transformation to a glyph outline. */

	EXPORT_DEF void TT_Transform_Outline(TT_Outline * outline, TT_Matrix * matrix);

	/* Apply a translation to a glyph outline. */

	EXPORT_DEF void TT_Translate_Outline(TT_Outline * outline, TT_F26Dot6 xOffset, TT_F26Dot6 yOffset);

	/* Apply a transformation to a vector. */

	EXPORT_DEF void TT_Transform_Vector(TT_F26Dot6 * x, TT_F26Dot6 * y, TT_Matrix * matrix);

	/* Compute A*B/C with 64 bits intermediate precision. */

	EXPORT_DEF TT_Long TT_MulDiv(TT_Long A, TT_Long B, TT_Long C);

	/* Compute A*B/0x10000 with 64 bits intermediate precision. */
	/* Useful to multiply by a 16.16 fixed float value.         */

	EXPORT_DEF TT_Long TT_MulFix(TT_Long A, TT_Long B);

	/* ----------------- character mapping support --------------- */

	/* Return the number of character mappings found in this file. */
	/* Returns -1 in case of failure (invalid face handle).        */
	/*                                                             */
	/* DON'T USE THIS FUNCTION!  IT HAS BEEN DEPRECATED!           */
	/*                                                             */
	/* It is retained for backwards compatibility only and will    */
	/* fail on 16bit systems.                                      */
	/*                                                             */
	/* You can now get the charmap count in the `num_CharMaps'     */
	/* field of a face's properties.                               */
	/*                                                             */

	EXPORT_DEF int TT_Get_CharMap_Count(TT_Face face);

	/* Return the ID of charmap number `charmapIndex' of a given face */
	/* used to enumerate the charmaps present in a TrueType file.     */

	EXPORT_DEF TT_Error TT_Get_CharMap_ID(TT_Face face, TT_UShort charmapIndex, TT_UShort * platformID,
										  TT_UShort * encodingID);

	/* Look up the character maps found in `face' and return a handle */
	/* for the one matching `platformID' and `platformEncodingID'     */
	/* (see the TrueType specs relating to the `cmap' table for       */
	/* information on these ID numbers).  Returns an error code.      */
	/* In case of failure, the handle is set to NULL and is invalid.  */

	EXPORT_DEF TT_Error TT_Get_CharMap(TT_Face face, TT_UShort charmapIndex, TT_CharMap * charMap);

	/* Translate a character code through a given character map   */
	/* and return the corresponding glyph index to be used in     */
	/* a TT_Load_Glyph() call.  This function returns 0 in case   */
	/* of failure.                                                */

	EXPORT_DEF TT_UShort TT_Char_Index(TT_CharMap charMap, TT_UShort charCode);

	/* --------------------- names table support ------------------- */

	/* Return the number of name strings found in the name table.  */
	/* Returns -1 in case of failure (invalid face handle).        */
	/*                                                             */
	/* DON'T USE THIS FUNCTION!  IT HAS BEEN DEPRECATED!           */
	/*                                                             */
	/* It is retained for backwards compatibility only and will    */
	/* fail on 16bit systems.                                      */
	/*                                                             */
	/* You can now get the number of name strings in a face with   */
	/* the `num_Names' field of its properties.                    */

	EXPORT_DEF int TT_Get_Name_Count(TT_Face face);

	/* Return the ID of the name number `nameIndex' of a given face */
	/* used to enumerate the charmaps present in a TrueType file.   */

	EXPORT_DEF TT_Error TT_Get_Name_ID(TT_Face face, TT_UShort nameIndex, TT_UShort * platformID,
									   TT_UShort * encodingID, TT_UShort * languageID, TT_UShort * nameID);

	/* Return the address and length of the name number `nameIndex' */
	/* of a given face in the variables `stringPtr' resp. `length'. */
	/* The string is part of the face object and shouldn't be       */
	/* written to or released.                                      */
	/*                                                              */
	/* Note that for an invalid platform ID a null pointer will be  */
	/* returned.                                                    */

	EXPORT_DEF TT_Error TT_Get_Name_String(TT_Face face, TT_UShort nameIndex, TT_String ** stringPtr,
										   TT_UShort * length);

#ifdef __cplusplus
}
#endif
#endif							/* FREETYPE_H */
/* END */
